home *** CD-ROM | disk | FTP | other *** search
/ PC Open 92 / PC Open 92 CD 2.bin / Demo / finereader 7 pro TRIAL / FR70pro_en_it.exe / Data1.cab / pdf_font.ps < prev    next >
Encoding:
Text File  |  2002-10-23  |  40.0 KB  |  1,268 lines
  1. %    Copyright (C) 1994-2002 artofcode LLC.  All rights reserved.
  2. % 
  3. % This software is provided AS-IS with no warranty, either express or
  4. % implied.
  5. % 
  6. % This software is distributed under license and may not be copied,
  7. % modified or distributed except as expressly authorized under the terms
  8. % of the license contained in the file LICENSE in this distribution.
  9. % 
  10. % For more information about licensing, please refer to
  11. % http://www.ghostscript.com/licensing/. For information on
  12. % commercial licensing, go to http://www.artifex.com/licensing/ or
  13. % contact Artifex Software, Inc., 101 Lucas Valley Road #110,
  14. % San Rafael, CA  94903, U.S.A., +1(415)492-9861.
  15.  
  16. % $Id: pdf_font.ps,v 1.23.2.6 2002/04/16 06:11:29 giles Exp $
  17. % pdf_font.ps
  18. % PDF font operations.
  19.  
  20. % ATAPY changes at 23.10.2002. Comments about changes started with string "(ATAPY changes)"
  21.  
  22. /.setlanguagelevel where { pop 2 .setlanguagelevel } if
  23. .currentglobal true .setglobal
  24. /pdfdict where { pop } { /pdfdict 100 dict def } ifelse
  25. GS_PDF_ProcSet begin
  26. pdfdict begin
  27.  
  28. % We cache the PostScript font in an additional element of the
  29. % font resource dictionary, called PSFont.
  30.  
  31. % ---------------- Encodings ---------------- %
  32.  
  33. % Apply a list of differences to an Encoding.
  34. % Note that the differences may cause the array to grow.
  35. /updateencoding {    % <encoding> <differences> updateencoding <enc'>
  36.     % Calculate the length of the result.
  37.   exch 0 2 index {
  38.     dup type /nametype ne { exch pop } { pop 1 add } ifelse
  39.   } forall
  40.   1 index length .max array dup 0 4 -1 roll putinterval
  41.   exch 0 exch {
  42.         % Stack: enc' code element
  43.     dup type /nametype ne
  44.       { exch pop }
  45.       { 3 copy put pop 1 add }
  46.     ifelse
  47.   } forall pop
  48. } bdef
  49.  
  50. % Get the Encoding for a font.
  51. /getencoding        % <base-encoding> <font-resource> getencoding <enc>
  52.  { /Encoding knownoget
  53.     { dup type /nametype eq
  54.        { 
  55.          % The published PDF specification says the Encoding name
  56.          % "must be" one of the 3 predefined Encodings, implying
  57.          % that an error should occur if it isn't.  However, Acrobat
  58.          % Reader simply ignores unknown names, and since there are
  59.          % some buggy applications that rely on this, we do the same.
  60.  
  61.          dup dup dup /MacRomanEncoding eq
  62.          exch /MacExpertEncoding eq or 
  63.          exch /WinAnsiEncoding eq or
  64.            { exch pop findencoding
  65.            }
  66.            { pop
  67.            }
  68.          ifelse
  69.        }
  70.        { dup /BaseEncoding knownoget
  71.       { findencoding 3 -1 roll pop exch
  72.       }
  73.      if
  74.      /Differences knownoget { updateencoding } if
  75.        }
  76.       ifelse
  77.     }
  78.    if
  79.  } bdef
  80.  
  81. % Rename a font with a generated name.
  82. /renamefont {        % <fontdict> renamefont <font'>
  83.   dup /FontName 2 copy get genfontname dup 5 1 roll put definefont
  84. } bind def
  85.  
  86. % Adjust a font according to the Encoding and Widths in the font resource.
  87. /adjustfont {        % <font-resource> <font> adjustfont <font'>
  88.   getfontencoding
  89.   getfontmetrics 4 -1 roll pop .updatefont { renamefont } if
  90. } bind def
  91.  
  92. % Get the (possibly modified) encoding of a font.
  93. /getfontencoding {    % <font-resource> <font> getfontencoding
  94.             %   <font-resource> <font> <Encoding|null>
  95.   1 index /Encoding known {
  96.     dup /Encoding .knownget { 2 index getencoding } { null } ifelse
  97.   } {
  98.     null
  99.   } ifelse
  100. } bdef
  101.  
  102. /find_in_diff     % <Differences> <index> find_in_diff <bool>
  103. { false exch 0 4 3 roll
  104.   { dup type /nametype ne { exch pop } { pop 1 add } ifelse
  105.     2 copy eq {
  106.       pop pop pop true 0 0 exit
  107.     } if
  108.   } forall
  109.   pop pop
  110. } bdef
  111.  
  112. % Get the metrics of a font, if specified.
  113. /getfontmetrics {    % <font-resource> <font> <Encoding|null> getfontmetrics
  114.             %   <font-resource> <font> <Encoding|null>
  115.             %   <Metrics|null>
  116.   2 index /Widths known {
  117.     dup null eq { pop dup /Encoding get } if
  118.     4 dict begin
  119.       /Encoding exch def
  120.       /Metrics Encoding length dict def
  121.       exch
  122.       dup /Widths oget /Widths exch def
  123.         % Stack: font font-res
  124.         % Note that widths are always based on a 1000-unit
  125.         % character space, but the FontMatrix may specify
  126.         % some other scale factor.  Compensate for this here,
  127.         % by scaling the Widths if necessary.
  128.       0.001 2 index /FontMatrix get 0 get div
  129.         % Stack: font font-res mscale
  130.       1 index /FirstChar oget dup 1 4 index /LastChar oget
  131.        {    % Stack: font font-res mscale first-char index
  132.      Encoding 1 index get
  133.      Widths 2 index 4 index sub oget
  134.          % Stack: font font-res mscale first-char index charname width
  135.      4 index mul
  136.         % The following 'loop' is only context for 'exit'.
  137.      {    
  138.         % Work around a bug in pdfTeX, which can generate Encoding
  139.         % vectors containing nulls :
  140.        1 index null eq { exit } if
  141.         % There is a hack here to deal with encodings where the
  142.         % same character appears more than once, because the Metrics
  143.         % dictionary works by character name, not by character code.
  144.         % We prefer to take (1) non-zero width, and (2) width for 
  145.         % the character code which appears in Differences.
  146.        Metrics 2 index .knownget not { 0 } if 0 ne {
  147.          5 index /Encoding knownoget not { exit } if
  148.          dup type /dicttype ne { pop exit } if
  149.          /Differences knownoget not { exit } if
  150.          3 index //find_in_diff exec not { exit } if
  151.        } if
  152.        2 copy Metrics 3 1 roll put
  153.        exit
  154.      } loop
  155.      pop pop pop
  156.        }
  157.       for pop
  158.         % Now fill in the MissingWidth for any encoded characters
  159.         % that aren't in Metrics already.  Note that built-in
  160.         % fonts may have Widths/FirstChar/LastChar but no
  161.         % FontDescriptor, so we must check for this.
  162.         % Stack: font font-res mscale
  163.       1 index /FontDescriptor knownoget {
  164.     Metrics exch
  165.     /MissingWidth knownoget { 2 index mul } { 0 } ifelse exch
  166.     Encoding {
  167.         % Stack: font font-res mscale missing-width metrics charname
  168.         % Work around the abovementioned pdfTeX bug.
  169.       dup null ne {
  170.         2 copy known not { 2 copy 4 index put } if pop
  171.       } {
  172.         pop
  173.       } ifelse
  174.     } forall pop pop pop
  175.       } {
  176.     pop
  177.       } ifelse
  178.     exch Encoding Metrics end
  179.   } {
  180.     null
  181.   } ifelse
  182. } bdef
  183.  
  184. currentdict /find_in_diff undef
  185.  
  186. % ---------------- Descriptors ---------------- %
  187.  
  188. % Partial descriptors for the 14 built-in fonts.  Note that
  189. % from PDF 1.1 to PDF 1.2, the meaning of the Flag 6 in the FontDescriptor
  190. % object has undergone a subtle change in its meaning which has serious
  191. % consequences for searching with Acrobat:
  192. % In PDF 1.1, the flag meant: Font has StandardEncoding
  193. % In PDF 1.2, the flag means: Font has (subset of) StandardRomanCharacterSet
  194. /standardfontdescriptors mark
  195.   /Courier mark /Flags 16#23 .dicttomark
  196.   /Courier-Oblique 1 index
  197.   /Courier-Bold 1 index
  198.   /Courier-BoldOblique 1 index
  199.   /Helvetica mark /Flags 16#20 .dicttomark
  200.   /Helvetica-Oblique 1 index
  201.   /Helvetica-Bold 1 index
  202.   /Helvetica-BoldOblique 1 index
  203.   /Times-Roman mark /Flags 16#22 .dicttomark
  204.   /Times-Bold 1 index
  205.   /Times-Italic mark /Flags 16#62 .dicttomark
  206.   /Times-BoldItalic 1 index
  207.   /Symbol mark /Flags 16#4 .dicttomark
  208.   /ZapfDingbats 1 index
  209. .dicttomark readonly def
  210.  
  211. % ---------------- Utilities ---------------- %
  212.  
  213. /.glyphpath {    % <glyphname> <boolean> .glyphpath -
  214.   % another glyphpath written in addxchar.ps does not work here...
  215.   currentfont 3 1 roll exch
  216.   currentfont dup length dict begin
  217.     { 1 index /Encoding eq { pop [ 3 -1 roll ] def } { def } ifelse } forall
  218.   currentdict end /.glyphpathfont exch definefont
  219.   setfont <00> exch charpath setfont
  220. } bdef
  221.  
  222. /makeboldfont {    % <basefont> <strokewidth> makeboldfont <boldfont>
  223.   10 dict begin
  224.     /strokewidth exch def
  225.     /basefont exch def
  226.     /FontMatrix matrix def
  227.     %/FontName basefont /FontName get def
  228.     /FontName /.boldfont def
  229.     /FontType 3 def
  230.     /Encoding basefont /Encoding get def
  231.     /FontBBox [ basefont /FontBBox get cvx exec
  232.       4 2 roll basefont /FontMatrix get transform
  233.       4 2 roll basefont /FontMatrix get transform
  234.     ] def
  235.     /BuildGlyph {
  236.       gsave
  237.       exch begin
  238.         basefont setfont
  239.         strokewidth setlinewidth
  240.         1 setlinejoin
  241.         newpath
  242.         0 0 moveto dup false .glyphpath stroke
  243.         0 0 moveto glyphshow
  244.         currentpoint setcharwidth
  245.       end
  246.       grestore
  247.     } bind def
  248.    currentdict
  249.   end
  250.   dup /FontName get exch definefont
  251. } bind def
  252.  
  253. % Fabricate a font name by adding ?'s on the end.
  254. /genfontname        % <name> genfontname <name>
  255.  { dup length string cvs
  256.     { (?) concatstrings
  257.       dup cvn FontDirectory exch known not { cvn exit } if
  258.     }
  259.    loop
  260.  } bdef
  261.  
  262. % Find a font, and adjust its encoding if necessary.
  263. /.pdfdfndict mark
  264.   /defaultfontname /Helvetica
  265. .dicttomark readonly def
  266.  
  267. % (ATAPY changes) 
  268. /calcAverageCharWidth { % [width_array] calcAverageCharWidth averageWidth
  269.     dup 0 exch { 
  270.         add
  271.     } forall exch % calc sum
  272.     0 exch { 
  273.         0 ne { 1 add } if 
  274.     } forall dup 0 eq { exch pop } { div } ifelse % sum / ( positive size )
  275. } bdef
  276. % (end of ATAPY changes) 
  277.  
  278. /pdffindfont {        % <font-resource> <fontname> pdffindfont <font>
  279.         % If the font isn't available, synthesize one based on
  280.         % its descriptor.
  281.   dup /Font resourcestatus {
  282.     pop pop findfont
  283.   } {
  284.     1 index /FontDescriptor knownoget {
  285.         % Stack: font-res fontname fontdesc
  286.       dup /Flags oget
  287.       dup 16#40 and -6 bitshift        % 1, oblique/italic
  288.       1 index 16#40000 and -17 bitshift add    % 2, bold
  289.         % (ATAPY changes) actually Adobe PDF documentation says "force bold on small size"
  290.       exch 16#2 and 2 bitshift add    % 8, serif
  291.         % We should look at the fixed flag, too.
  292.         % Stack: font-res fontname fontdesc properties
  293.       1 index /FontName oget exch
  294.         % Analyzes font name and extract "Narrow" property
  295.         % which is not described by the FontDescriptor Flags.
  296.  
  297.         % (ATAPY changes) We also extract "Bold" property, 4 -> 6 in the next line:
  298.       0 2 index .fontnameproperties 6 and or
  299.  
  300.         % (ATAPY changes) Some PDF-s contain no "Italic" flag in /Flags, but have negative /ItalicAngle
  301.         dup 1 and 0 eq {
  302.             % Stack: font-res fontname fontdesc fontname properties
  303.             2 index /ItalicAngle oget 0 lt {
  304.                 (Negative /ItalicAngle with no italic flag, force italic...\n) print
  305.                 1 or
  306.             } if
  307.         } if
  308.  
  309.         % (ATAPY changes) Try to analyze width table for narrow font
  310.         % Stack: font-res fontname fontdesc fontname properties
  311.         
  312.         4 index /Widths get calcAverageCharWidth (Avarage char width = ) print dup ==
  313.         
  314.         % Then if width is too small and font is sanserif turn on "Narrow" flag
  315.  
  316.         [510 530 540 550] % predefined average widths for Helvetica [normal it bold bold-it]
  317.         2 index 3 and get % extract bold and italic properties to get corresponding width
  318.         (Base font char width = ) print dup ==
  319.         le { dup 8 and 0 eq { 
  320.                 4 or (Too narrow font, try turn on "Narrow" flag...\n) print 
  321.             } if 
  322.         } if
  323.         
  324.         % (ATAPY changes) End of changes
  325.  
  326.         % Rebind the default font name to Helvetica so that
  327.         % fonts with no properties are handled correctly.
  328.       //.pdfdfndict begin .substitutefontname end
  329.         % Stack: font-res fontname fontdesc substname|null
  330.       Fontmap 1 index known not {
  331.         % No available good substitution, use the standard one.
  332.     pop 1 index .substitutefont
  333.       } if
  334.       QUIET not {
  335.     (Substituting font ) print dup =only
  336.     ( for ) print 2 index =only (.) = flush
  337.       } if
  338.       3 -1 roll pop findfont
  339.         % Stack: font-res fontdesc font
  340.         % If this is a small-caps font, replace the CharString
  341.         % entries for a..z.
  342.       exch /Flags oget 16#20000 and 0 ne {
  343.     true .copyfontdict
  344.     dup /CharStrings 2 copy get dup length dict .copydict
  345.     4 index /FirstChar get 97 .max
  346.     5 index /LastChar get 122 .min 1 exch {
  347.         % Stack: font-res font' font' /CharStrings charstrings code
  348.         % Note that this only remaps a-z, not accented characters.
  349.       5 index /Widths oget 1 index 7 index /FirstChar get sub oget
  350.       1 string dup 0 5 -1 roll put
  351.         % Stack: font-res font' font' /CharStrings charstrings code
  352.         %   width (x)
  353.       2 index exch dup cvn exch
  354.       dup 0 2 copy get 32 sub put 4 -1 roll {
  355.             % Stack: operand (X) width
  356.         0 setcharwidth exch pop
  357.         currentfont /FontMatrix get matrix invertmatrix concat
  358.         0.7 dup scale 0 0 moveto show
  359.       } /exec cvx 4 packedarray cvx put
  360.     } for put
  361.     renamefont
  362.       } if
  363.     } {
  364.         % No descriptor available, use the default algorithm.
  365.       findfont
  366.     } ifelse
  367.   } ifelse adjustfont
  368. } bdef
  369. /findpdffont {    % <font-resource> <fontname> findpdffont <font>
  370.   {} 3 1 roll            % proc fnres fnname
  371.   [
  372.     [ (,Bold)        { .03 makeboldfont } ]
  373.     [ (,BoldItalic)    { .03 makeboldfont [ 1 0 .3 1 0 0 ] makefont } bind ]
  374.     [ (,Italic)        { [ 1 0 .3 1 0 0 ] makefont } bind ]
  375.   ] {
  376.     1 index dup length string cvs
  377.     1 index 0 get tailmatch {    % proc fnres fnname []
  378.       3 -1 roll pop exch 1 get    % proc fnres pre-fnname proc
  379.       4 -1 roll pop 3 1 roll    % proc fnres pre-fnname
  380.       exit
  381.     } { pop pop } ifelse     % proc fnres fnname
  382.   } forall
  383.   pdffindfont exch exec
  384. } bdef
  385.  
  386. % ---------------- Type 1 fonts ---------------- %
  387.  
  388. /buildType1        % <Type1-font-resource> buildType1 <font>
  389.  { dup /BaseFont get pdffindfont
  390.  } bdef
  391.  
  392. % The state dictionary for the embedded Type 1 font reading procedure
  393. % has the following keys and values:
  394. %    data - stream (filter)
  395. %    buffer, buffer2 - string
  396. %    hexify - procedure to convert buffer to hex if needed
  397. %    leftstr - string containing (non-negative) integer
  398. %    sectionstr - string containing a character 0 .. 3
  399. %    stream - (stream) dictionary
  400. %    proc - procedure of the form {-dict- type1read}
  401. %       pfbhdr - string containing 16#80 if PFB, 0 otherwise
  402. % When the procedure is executing, this dictionary is current.
  403. % leftstr and sectionstr are strings so that we can change their values
  404. % reliably in case the font executes a restore!
  405. % We also have to do something special about embedded fonts that
  406. % execute definefont more than once -- that is the function of topFontDict.
  407.  
  408. % Read an embedded Type 1 font.
  409. /readfontfilter {    % <proc> readfontfilter <filter>
  410.   0 () /SubFileDecode filter
  411. } bdef
  412. /readtype1dict 5 dict dup begin
  413.   /definefont {
  414.     dup topFontDict eq topFontDict null eq or {
  415.       dup wcheck not { dup length dict copy } if
  416.       exch pop savedFontName exch
  417.     } if
  418.     //systemdict /definefont get exec
  419.   } bdef
  420.   /eexec {
  421.     % Assume the font dictionary is directly below the file on the stack
  422.     count 0 gt { /topFontDict 2 index cvlit store } if
  423.     55665 /eexecDecode filter
  424.     //systemdict begin readtype1dictcopy begin cvx stopped
  425.     currentdict readtype1dictcopy eq { end } if
  426.     currentdict //systemdict eq { end } if
  427.      { stop } if
  428.   } bdef
  429. end readonly def
  430. /readtype1 {        % <font-resource> <stream-dict> readtype1 <font>
  431.         % Read the definition, using a procedure-based filter
  432.         % that turns binary/hex conversion on and off
  433.         % at the right times.
  434.    1 index exch
  435.    PDFfile fileposition 3 1 roll
  436.    11 dict begin
  437.      /leftstr (          ) 10 string copy def
  438.        dup /Length1 oget leftstr cvs pop
  439.      /sectionstr <00> 1 string copy def
  440.      /pfbhdr <00> 1 string copy def
  441.      /stream 1 index def
  442.      true resolvestream /data exch def
  443.      /buffer 1000 string def        % arbitrary
  444.      /buffer2 buffer length 2.1 div cvi 1 sub string def
  445.      /hexify /buf2hex load def
  446.    currentdict end
  447.    /type1read cvx 2 array astore cvx dup 0 get /proc 2 index put
  448.    readfontfilter
  449.         % Some buggy embedded fonts leave extra junk on the stack,
  450.         % so we have to make a closure that records the stack depth
  451.         % in a fail-safe way.
  452.    //systemdict begin
  453.         % The PDF specification is somewhat muddy about whether
  454.         % an embedded font's name is supposed to be the BaseFont
  455.         % from the Font object or the FontName from the descriptor.
  456.         % Acrobat Distiller requires the former.  Save away the
  457.         % name so we can substitute it at definefont time.
  458.    //readtype1dict dup length 3 add dict copy begin
  459.    1 index /BaseFont oget /savedFontName exch def
  460.    /topFontDict null def
  461.    /readtype1dictcopy currentdict def
  462.     { run } aload pop count 1 sub 2 packedarray cvx exec
  463.    end end
  464.    count exch sub { pop } repeat
  465.    PDFfile 3 -1 roll setfileposition
  466.    /BaseFont oget findfont
  467.    adjustfont
  468.  } bdef
  469.  
  470. % Execute the appropriate reading procedure.
  471. /type1read        % <dict> type1read <string>
  472.  { begin leftstr cvi
  473.     { type1read0 type1read1 type1read2 type1read3 } sectionstr 0 get get exec
  474.    (          ) leftstr copy cvs pop end
  475.  } bdef
  476.  
  477. % Read the next block of data into the buffer.
  478. /type1readdata        % <left> <buffer> type1readdata <substring> <left'>
  479.  { 0 2 index 2 index length .min getinterval
  480.         % Adobe requires readstring to signal an error if given
  481.         % an empty string.  Work around this nonsense here.
  482.    dup length 0 ne { data exch readstring pop } if
  483.    dup length 3 -1 roll exch sub
  484.    DEBUG
  485.     { dup =only ( read ) print
  486.       1 index length =only (: ) print
  487.       1 index == flush
  488.     } if
  489.  } bdef
  490.  
  491. % Read the initial byte to see if we need to skip a 6 byte PFB header
  492. /type1read0 {         % <left> type1read0 <string> <left'>
  493.   sectionstr 0 1 put    % either way we go to the next stage
  494.   pfbhdr type1readdata
  495.   1 index 0 get 16#80 eq {
  496.     (\n   **** Warning: Embedded Type1 font in PFB format is not valid PDF.)
  497.     pdfformaterror
  498.     DEBUG { (skipping PFB header) = flush } if
  499.     exch pop buffer 0 5 getinterval type1readdata exch
  500.     dup 4 get 256 mul 1 index 3 get add 256 mul
  501.     1 index 2 get add 256 mul 1 index 1 get add
  502.     DEBUG { (PFB segment length = ) print dup = } if
  503.     exch pop  % discard the string keeping the PFB segment length
  504.     2 copy ne {
  505.       (\n   **** Warning: Type 1 PFB segment length and Length 1 value do not match.)
  506.       pdfformaterror
  507.       exch     % keep the PFB length instead
  508.     } if
  509.     pop
  510.     buffer type1readdata    % go ahead and read a block
  511.   }
  512.   if    % if not PFB, return pfbhdr string (first char of file, usually %).
  513. } bdef
  514.  
  515. % Read the next block of the initial text portion.
  516. /type1read1 {        % <left> type1read1 <string> <left'>
  517.   DEBUG { (read1 ) print } if
  518.   dup 0 eq {
  519.     pop sectionstr 0 2 put
  520.     stream /Length2 oget
  521.             % Determine whether to hexify data for eexec.
  522.     dup 8 lt {
  523.       type1read2    % Hexify.
  524.     } {
  525.       DEBUG { (read2 ) print } if
  526.       pfbhdr 0 get 16#80 eq {
  527.         % eat 6 more bytes of PFB junk before proceeding
  528.     DEBUG { (skipping PFB header in segment 2) = flush } if
  529.     buffer 0 6 getinterval type1readdata exch
  530.         dup 5 get 256 mul 1 index 4 get add 256 mul
  531.     1 index 3 get add 256 mul 1 index 2 get add
  532.         DEBUG { (PFB segment length = ) print dup = } if
  533.     exch pop  % discard the string keeping the PFB segment length
  534.     2 copy ne {
  535.           (\n   **** Warning: Type 1 PFB segment length and Length 2 value do not match.)
  536.           pdfformaterror
  537.       dup =
  538.       exch         % keep the PFB length instead
  539.     } if
  540.       pop
  541.       } if
  542.       buffer2 type1readdata exch
  543.             % The check doesn't have to be 100% accurate:
  544.             % hexifying is always OK.
  545.       dup 0 8 getinterval 0 exch { or } forall
  546.       128 ge {
  547.     /hexify { } store
  548.     /buffer2 buffer def    % We don't need an intermediate buffer.
  549.       } if hexify exch
  550.     } ifelse
  551.   } {
  552.     buffer type1readdata
  553.   } ifelse
  554. } bdef
  555.  
  556. % Convert a string from binary to hex for eexec.
  557. % Free variables: buffer.
  558. /buf2hex {        % <string> buf2hex <hexstring>
  559.   buffer /ASCIIHexEncode filter dup 3 -1 roll writestring closefile
  560.   buffer (>) search pop exch pop exch pop
  561. } bdef
  562.  
  563. % Read the next block of the encrypted portion.
  564. /type1trailer
  565. (0000000000000000000000000000000000000000000000000000000000000000\n\
  566. 0000000000000000000000000000000000000000000000000000000000000000\n\
  567. 0000000000000000000000000000000000000000000000000000000000000000\n\
  568. 0000000000000000000000000000000000000000000000000000000000000000\n\
  569. 0000000000000000000000000000000000000000000000000000000000000000\n\
  570. 0000000000000000000000000000000000000000000000000000000000000000\n\
  571. 0000000000000000000000000000000000000000000000000000000000000000\n\
  572. 0000000000000000000000000000000000000000000000000000000000000000\n\
  573. cleartomark\n)
  574. readonly def
  575. /type1read2 {        % <left> type1read2 <string> <left'>
  576.   DEBUG { (read2 ) print } if
  577.    dup 0 eq
  578.     { pop sectionstr 0 3 put
  579.       stream /Length3 oget
  580.       dup 0 eq
  581.        { DEBUG { (trailer ) print } if
  582.      type1trailer exch
  583.        }
  584.        { 
  585.          pfbhdr 0 get 16#80 eq {
  586.            % eat 6 more bytes of PFB junk before proceeding
  587.        DEBUG { (skipping PFB header in segment 3) = flush } if
  588.        buffer 0 6 getinterval type1readdata exch
  589.            dup 5 get 256 mul 1 index 4 get add 256 mul
  590.        1 index 3 get add 256 mul 1 index 2 get add
  591.            DEBUG { (PFB segment length = ) print dup = } if
  592.        exch pop  % discard the string keeping the PFB segment length
  593.        2 copy ne {
  594.            (\n   **** Warning: Type 1 PFB segment length and Length 3 value do not match.)
  595.            pdfformaterror
  596.          exch     % keep the PFB length instead
  597.        } if
  598.        pop
  599.        (\n) pdfformaterror
  600.          } if
  601.          type1read3
  602.        }
  603.       ifelse
  604.     }
  605.     { buffer2 type1readdata exch hexify exch
  606.     }
  607.    ifelse
  608. } bdef
  609.  
  610. % Read the next block of the final text portion.
  611. % When finished, this procedure returns an empty string.
  612. /type1read3        % <left> type1read3 <string> <left'>
  613.  { DEBUG { (read3 ) print } if
  614.    buffer type1readdata
  615.  } bdef
  616.  
  617. % ---------------- Type 3 fonts ---------------- %
  618.  
  619. /.notdefEncoding 256 { /.notdef } repeat 256 packedarray def
  620.  
  621. /buildType3 {        % <Type3-font-resource> buildType3 <font>
  622.   8 dict begin
  623.     /FontType 3 def
  624.     /Resources 1 index /Resources knownoget { oforce } { 0 dict } ifelse def
  625.     /FontBBox 1 index /FontBBox get cvx def
  626.     /FontMatrix 1 index /FontMatrix oget def
  627.     /CharProcs 1 index /CharProcs oget def
  628.     1 index /Widths knownoget {
  629.       /Widths exch def
  630.       /FirstChar 1 index /FirstChar oget def
  631.       /LastChar 1 index /LastChar oget def
  632.     } if
  633.     /FontName 1 index /Name get genfontname def
  634.     /Encoding .notdefEncoding 2 index getencoding def
  635.         % We have to define BuildChar rather than BuildGlyph:
  636.         % there is no PDF equivalent of glyphshow, and we need
  637.         % the character code to access the Widths.
  638.     /BuildChar {
  639.         % Stack: font charcode
  640.       1 index begin 3 dict begin
  641.       /Font 3 -1 roll def /CharCode 1 index def
  642.       % Make unknown characters map to /.notdef
  643.       Encoding exch get dup CharProcs exch known
  644.         { CharProcs exch oget }
  645.     { pop CharProcs /.notdef oget }
  646.       ifelse
  647.       PDFfile fileposition exch
  648.       false resolvestream
  649.         % Stack: filepos stream
  650.         % Don't let setgcolor set the color inside the BuildGlyph
  651.         % procedure, because this causes an /undefined error.
  652.       q null /FillColor gput null /StrokeColor gput
  653.       Font /Resources get exch pdfopdict .pdfruncontext
  654.       Q
  655.       PDFfile exch setfileposition
  656.       end end
  657.     } bdef
  658.     FontName currentdict end definefont exch pop
  659. } bdef
  660. /.adjustcharwidth {    % <wx> <wy> .adjustcharwidth <wx'> <wy'>
  661.   /Widths where {
  662.     begin
  663.     CharCode FirstChar ge CharCode LastChar le and {
  664.       exch pop Widths CharCode FirstChar sub get exch
  665.     } if end
  666.   } if
  667. } bdef
  668.  
  669. % ---------------- TrueType fonts ---------------- %
  670.  
  671. /TTfonts mark
  672.   /Arial /Helvetica
  673.   /Arial,Italic /Helvetica-Oblique
  674.   /Arial,Bold /Helvetica-Bold
  675.   /Arial,BoldItalic /Helvetica-BoldOblique
  676.   /CourierNew /Courier
  677.   /CourierNew,Bold /Courier-Bold
  678.   /TimesNewRoman /Times-Roman
  679.   /TimesNewRoman,Italic /Times-Italic
  680.   /TimesNewRoman,Bold /Times-Bold
  681.   /TimesNewRoman,BoldItalic /Times-BoldItalic
  682.   %
  683.   /ArialBlack,Italic /Arial-BlackItalic
  684.   /ArialNarrow,Bold /ArialNarrow-Bold
  685.   /ArialNarrow,BoldItalic /ArialNarrow-BoldItalic
  686.   /ArialNarrow,Italic /ArialNarrow-Italic
  687.   /BookAntiqua,Bold /BookAntiqua-Bold
  688.   /BookAntiqua,BoldItalic /BookAntiqua-BoldItalic
  689.   /BookAntiqua,Italic /BookAntiqua-Italic
  690.   /BookmanOldStyle,Bold /BookmanOldStyle-Bold
  691.   /BookmanOldStyle,BoldItalic /BookmanOldStyle-BoldItalic
  692.   /BookmanOldStyle,Italic /BookmanOldStyle-Italic
  693.   /CenturyGothic,Bold /CenturyGothic-Bold
  694.   /CenturyGothic,BoldItalic /CenturyGothic-BoldItalic
  695.   /CenturyGothic,Italic /CenturyGothic-Italic
  696.   /ComicSansMS,Bold /ComicSansMS-Bold
  697.   /CourierNew,Bold /CourierNewPS-BoldMT
  698.   /CourierNew,BoldItalic /CourierNewPS-BoldItalicMT
  699.   /CourierNew,Italic /CourierNewPS-ItalicMT
  700.   /FranklinGothicMedium,Italic /FranklinGothic-MediumItalic
  701.   /Garamond,Bold /Garamond-Bold
  702.   /Garamond,Italic /Garamond-Italic
  703.   /Georgia,Bold /Georgia-Bold
  704.   /Georgia,BoldItalic /Georgia-BoldItalic
  705.   /Georgia,Italic /Georgia-Italic
  706.   /Tahoma,Bold /Tahoma-Bold
  707.   /TrebuchetMS,Bold /TrebuchetMS-Bold
  708.   /TrebuchetMS,BoldItalic /Trebuchet-BoldItalic
  709.   /TrebuchetMS,Italic /TrebuchetMS-Italic
  710.   /Verdana,Bold /Verdana-Bold
  711.   /Verdana,BoldItalic /Verdana-BoldItalic
  712.   /Verdana,Italic /Verdana-Italic
  713. .dicttomark readonly def
  714.  
  715. /buildTrueType {    % <TrueType-font-resource> buildTrueType <font>
  716.   dup /BaseFont get
  717.   dup TTfonts exch .knownget {
  718.     exch pop
  719.         % Hack required by the PDF specification: if the
  720.         % font resource has Subtype = /TrueType but the actual
  721.         % (installed) font is not a TrueType font, ignore the
  722.         % Encoding in the font resource.  However, all current
  723.         % versions of Acrobat Reader have the 14 base TrueType
  724.         % fonts built in, so this produces incorrect output for
  725.         % badly designed PDF files that specify these file names
  726.         % with /Subtype = /TrueType but no embedded definition.
  727.         % Compensate for this by removing the /Subtype key when
  728.         % looking up the font.
  729.     exch dup length dict copy dup /Subtype null put exch
  730.   } if
  731.   pdffindfont    % findfont for PDF
  732.   % disable the auto-bold and auto-italic since it sometimes applies
  733.   % so an already bold or italic substitute font
  734.   %findpdffont    % findfont and auto-bold and/or auto-italic font for PDF
  735. } bdef
  736.  
  737. % Read an embedded TrueType font.
  738. /readtruetype {        % <font-resource> <stream-dict> readtruetype <font>
  739.         % This is much simpler than readtype1, because we don't
  740.         % have to deal with the tripartite .PFB format.
  741.   1 index exch
  742.   PDFfile fileposition 3 1 roll
  743.   true resolvestream readfontfilter
  744.         % Stack: filepos fontres stream
  745.   1 index /Subtype get /CIDFontType2 eq {
  746.     .loadttcidfont
  747.         % Stack: filepos fontres cidfont
  748.     1 index /CIDToGIDMap knownoget {
  749.       dup /Identity eq {
  750.     pop
  751.       } {
  752.     true resolvestream
  753.         % The following doesn't work for CIDToGIDMaps with more
  754.         % than 32K-1 entries.  We'll fix it later if necessary.
  755.         % Stack: filepos fontres font mapstream
  756.     dup 2 index /CIDCount oget 2 mul string readstring pop exch closefile
  757.     exch dup length 5 add dict .copydict
  758.     dup /FID undef
  759.     dup /CIDMap 4 -1 roll put
  760.     dup /CIDFontName get exch /CIDFont defineresource
  761.       } ifelse
  762.     } if
  763.   } {
  764.     null 2 index getencoding .loadpdfttfont
  765.   } ifelse
  766.   exch pop
  767.   PDFfile 3 -1 roll setfileposition
  768.         % Ignore both the Encoding and the Widths.
  769.   exch pop
  770. } bdef
  771.  
  772. % ---------------- Type 0 fonts ---------------- %
  773.  
  774. % Predefine the known CMaps, but only create them on demand.
  775. /knownCMaps mark
  776.   /Identity-H { /Identity-H 0 makeIdentityCMap }
  777.   /Identity-V { /Identity-V 1 makeIdentityCMap }
  778. .dicttomark def
  779.  
  780. /makeIdentityCMap {        % <cmapname> <wmode> .makeIdentityCMap -
  781.   .currentglobal true .setglobal 3 1 roll
  782.   /CIDInit /ProcSet findresource begin
  783.   12 dict begin
  784.     begincmap
  785.     /WMode exch def
  786.     /CMapName exch def
  787.     /CIDSystemInfo 3 dict dup begin
  788.       /Registry (Adobe) def
  789.       /Ordering (Identity) def
  790.       /Supplement 0 def
  791.     end def
  792.     %/CMapName (see above)
  793.     /CMapVersion 1 def
  794.     /CMapType 1 def
  795.     %WMode (see above)
  796.     % The PDF documentation says that these CMaps map CIDs
  797.     % "1 to 65,536".  This is a misprint for 0 to 65,535.
  798.     1 begincodespacerange
  799.     % <0001> <00ff>  <0100> <ffff>
  800.       <0000> <ffff>
  801.     endcodespacerange
  802.     1 begincidrange
  803.     % <0001> <00ff> 1   <0100> <ffff> 256
  804.       <0000> <ffff> 0
  805.     endcidrange
  806.     endcmap
  807.     CMapName currentdict /CMap defineresource
  808.     knownCMaps CMapName 2 index put
  809.   end        % CMap
  810.   end        % CIDInit ProcSet
  811.   exch .setglobal
  812. } bdef
  813.  
  814. /buildType0 {        % <Type0-font-resource> buildType0 <font>
  815.   dup /BaseFont get    % FontName
  816.   1 index /Encoding oget
  817.   dup type /nametype eq {
  818.     dup /CMap resourcestatus {
  819.     pop pop /CMap findresource
  820.     } {
  821.     knownCMaps 1 index .knownget
  822.       { exch pop exec } { /undefined signalerror } ifelse
  823.     } ifelse
  824.   } {
  825.     PDFfile fileposition exch
  826.     dup /CMapName get exch true resolvestream cvx exec
  827.     /CMap findresource
  828.     exch PDFfile exch setfileposition
  829.   } ifelse        % CMap
  830.   [
  831.     3 index /DescendantFonts oget { exec resourcefont } forall
  832.   ]            % subfonts
  833.   composefont
  834.         % Stack: fontres font
  835.   1 index /FontMatrix knownoget {
  836.     dup aload pop true {0 0 1 0 0 1} {3 -1 roll eq and} forall {
  837.       1 index exch makefont exch /FontName get exch definefont
  838.     } {
  839.       pop
  840.     } ifelse
  841.   } if exch pop
  842. } bdef
  843.  
  844. % ---------------- CIDFontType0/2 fonts ---------------- %
  845.  
  846. % Insert metrics into a CIDFont, by saving the PDF W, W2, DW, and DW2
  847. % arrays and using a (currently very inefficient) CDevProc.
  848. % For detail, refer "PDF Reference" third edition, p. 337,
  849. % "5.6.3 CIDFonts" and table "Entries in a CIDFont dictionary".
  850.  
  851. /.pdfDefaultDW  1000 def
  852. /.pdfDefaultDW2 [ 880 -1000 ] def
  853.  
  854. /addCIDmetrics {    % <CIDFont-resource> <CIDFont> addCIDmetrics <fontdict>
  855.   dup length 5 add dict .copydict
  856.   dup /FID undef
  857.   dup /UniqueID undef
  858.   dup /XUID undef
  859.     % Insert the widths into the font.
  860.  
  861.     % Stack: pdfresource newfont
  862.  
  863.   1 index /DW .knownget {
  864.     1 index /DW 3 -1 roll put
  865.     } {
  866.     dup /DW .pdfDefaultDW put
  867.     } ifelse
  868.  
  869.  
  870.   1 index /W .knownget {
  871.     dup 2 index /W 3 -1 roll put
  872.     .pdfMakeInternalW 1 index /.internalW 3 -1 roll put
  873.   } if
  874.  
  875.  
  876.   1 index /DW2 .knownget {
  877.     1 index /DW2 3 -1 roll put
  878.   } {
  879.     dup /DW2 .pdfDefaultDW2 put
  880.   } ifelse
  881.  
  882.  
  883.   1 index /W2 .knownget {
  884.     dup 2 index /W2 3 -1 roll put
  885.     .pdfMakeInternalW2 1 index /.internalW2 3 -1 roll put
  886.   } if
  887.  
  888.  
  889.   dup /CDevProc 1 index /CIDWProc load /exec load 3 packedarray cvx put
  890.   exch pop
  891. } bdef
  892.  
  893. /.pdfMakeInternalMTXArray { % <mtx_array> <item_size> .pdfConvertInternalW <mtx_array'>
  894.  
  895.   % convert /W or /W2 to internal expression
  896.   %
  897.   %   mtx_array: original /W or /W2 array
  898.   %   item_size: number of metrics values per CID
  899.   %
  900.   %   for detail of the metrics list format in PDF,
  901.   %   refer PDF Ref. p.317 "Glyph Metrics in CIDFonts".
  902.   % 
  903.   %   format of single entry in internal expression
  904.   %
  905.   %     [
  906.   %       [cid_begin cid_end]
  907.   %       value_is_varied (bool)
  908.   %       [ [values for cid_begin...]
  909.   %         [values for cid_begin + 1]
  910.   %         ... ]
  911.   %     ]
  912.   %
  913.  
  914.   7 dict
  915.   begin
  916.     /itemSize exch def
  917.     /M exch def            % original /W or /W2
  918.     /Msize M length def
  919.     /Mi { M i get } def        % W[i]
  920.     /Mi1 { M i 1 add get } def    % W[i + 1]
  921.     /putMTXEntry <<
  922.       /arraytype   {
  923.          [
  924.            [Mi Mi Mi1 length add 1 sub]
  925.            true
  926.            [
  927.              0 itemSize Mi1 length 1 sub {
  928.                [ exch 1 1 index itemSize add 1 sub { Mi1 exch get } for ]
  929.              } for
  930.            ]
  931.          ]
  932.          /i i 2 add def
  933.       }
  934.       /integertype {
  935.          [
  936.            [Mi Mi1]
  937.            false
  938.            [[ i 2 add 1 i 1 add itemSize add { M exch get } for ]]
  939.          ]
  940.          /i i 3 add def
  941.       }
  942.     >> def
  943.  
  944.     /i 0 def
  945.  
  946.     [ { putMTXEntry Mi1 type get exec i Msize ge { exit } if } loop ]
  947.   end
  948. } def
  949.  
  950. /.pdfMakeInternalW  { dup length 0 gt { 1 .pdfMakeInternalMTXArray } if } def
  951. /.pdfMakeInternalW2 { dup length 0 gt { 3 .pdfMakeInternalMTXArray } if } def
  952.  
  953. /.pdfGetMTXByCID { % <internalMTXArray> <cid>
  954.                    %     .pdfGetMTXByCID
  955.                    %         { <MTXEntry> true | false }
  956.  
  957.   % get values for given CID from internal format of /W or /W2
  958.  
  959.   exch
  960.   {
  961.     {
  962.       dup 0 get {} forall      % Stack: <cid> <entry> <cid_0> <cid_1>
  963.       3 index lt { pop pop false exit } if
  964.       2 index exch sub dup 0 lt { pop pop false exit } if
  965.       1 index 1 get not { pop 0 } if
  966.       exch 2 get exch get true exit
  967.     } loop
  968.     { exit } if
  969.   } forall
  970.   dup type /arraytype eq { exch pop true } { pop false } ifelse
  971. } def
  972.  
  973.  
  974. % Apply the [D]W[2] metrics to a character before displaying.
  975. /CIDWProc {        % <w0x> <w0y> <llx> <lly> <urx> <ury>
  976.             %   <w1x> <w1y> <vx> <vy> <cid> <font> CIDWproc
  977.             %   <w0x'> ... <vy'>
  978.  
  979.   begin % push <font> to currentdict
  980.     % <w1x> <w1y> <vx> <vy> won't be used and replaced, discard now
  981.     5 1 roll pop pop pop pop
  982.  
  983.     {
  984.       currentdict /DW .knownget not {   % no DW
  985.         .pdfDefaultDW exit              % replace <w0x> by defaultDW
  986.       } if
  987.  
  988.       currentdict /.internalW .knownget not {    % no W
  989.         exit                            % use already-stacked DW
  990.       } if
  991.  
  992.       dup length 0 eq {                 % W is null array
  993.         pop                             % discard unusable W
  994.         exit                            % use already-stacked DW
  995.       } if
  996.  
  997.       % W is finite array, try to get W_cid
  998.       2 index .pdfGetMTXByCID {           % got W, discard DW
  999.         exch pop {} forall
  1000.         exit
  1001.       } if
  1002.  
  1003.       exit
  1004.     } loop
  1005.  
  1006.     1000 div                    % <w0x'> (normalized W)
  1007.     0                           % <w0y'>
  1008.  
  1009.     % Stack: <w0x> <w0y> <llx> <lly> <urx> <ury> <cid> <w0x'> <w0y'>
  1010.     9 -2 roll pop pop           % discard <w0x> <w0y>
  1011.     7  2 roll                   % put <w0x'> <w0y'>
  1012.  
  1013.     % Stack: <w0x'> <w0y'> <llx> <lly> <urx> <ury> <cid>
  1014.     0                           % <w1x'>
  1015.     exch                        % put <w1x'>
  1016.  
  1017.     % Stack: <w0x'> <w0y'> <llx> <lly> <urx> <ury> <w1x'> <cid>
  1018.     {
  1019.       currentdict /DW2 .knownget not {  % no DW2, use defaultDW2
  1020.         .pdfDefaultDW2 exit
  1021.       } if
  1022.  
  1023.       currentdict /.internalW2 .knownget not {   % has DW2, no W2
  1024.         exit                            % use already-stacked DW2
  1025.       } if
  1026.  
  1027.       dup length 0 eq {                 % W2 is null array
  1028.         pop                             % discard unusable W2
  1029.         exit                            % use already-stacked DW2
  1030.       } if
  1031.  
  1032.       2 index .pdfGetMTXByCID {        % got W2_cid, discard DW2
  1033.         exch pop
  1034.         exit
  1035.       } if
  1036.  
  1037.       % could not get W2_cid
  1038.       exit
  1039.  
  1040.     } loop
  1041.  
  1042.     exch pop                            % discard <cid>
  1043.  
  1044.  
  1045.     % Stack: <w0x'> <w0y'> <llx> <lly> <urx> <ury> <w1x'> { [<vy'> <w1y'>] | [<w1y'> <vx'> <vy'>] }
  1046.     dup length 2 eq {                   % this is DW2
  1047.       {1000 div} forall exch
  1048.       4 index 7 index add 2 div         % <vx'> = (<urx> + <llx>) / 2
  1049.       exch
  1050.     }{                                  % assume W2
  1051.       {1000 div} forall
  1052.     } ifelse
  1053.   end                                   % recover currentdict
  1054.  
  1055. } def
  1056.  
  1057.  
  1058.  
  1059. %----------------------------------------------------------------
  1060.  
  1061. % <string> <match> tailmatch ==> <pre> true
  1062. %                            ==> <string> false
  1063. /tailmatch {
  1064.   2 copy length 1 index length .min
  1065.   dup 2 index length exch sub exch getinterval
  1066.   1 index eq {
  1067.     length 1 index length exch sub
  1068.     0 exch getinterval true
  1069.   } {
  1070.     pop false
  1071.   } ifelse
  1072. } bind def
  1073.  
  1074. /makeboldcidfont {
  1075.   16 dict begin
  1076.     /strokewidth exch def
  1077.     /basecidfont exch def
  1078.     /FontMatrix [ 1 0 0 1 0 0 ] def
  1079.  
  1080.     /CIDFontName /.boldfont def
  1081.     /CIDFontType 1 def
  1082.  
  1083.     /basefont-H /.basefont-H /Identity-H [ basecidfont ] composefont def
  1084.     /basefont-V /.basefont-V /Identity-V [ basecidfont ] composefont def
  1085.  
  1086.     /CIDSystemInfo dup basecidfont exch get def
  1087.     /FontBBox [ basecidfont /FontBBox get cvx exec
  1088.       4 2 roll basecidfont /FontMatrix get transform
  1089.       4 2 roll basecidfont /FontMatrix get transform
  1090.     ] def
  1091.  
  1092.     /tmpstr 2 string def
  1093.     /BuildGlyph {
  1094.       gsave
  1095.       exch begin
  1096.         dup 256 idiv tmpstr exch 0 exch put
  1097.         256 mod tmpstr exch 1 exch put
  1098.         rootfont /WMode known { rootfont /WMode get 1 eq } { false } ifelse
  1099.         { basefont-V } { basefont-H } ifelse setfont
  1100.         strokewidth setlinewidth
  1101.         1 setlinejoin
  1102.         newpath
  1103.         0 0 moveto tmpstr false charpath stroke
  1104.         0 0 moveto tmpstr show
  1105.         currentpoint setcharwidth
  1106.       end
  1107.       grestore
  1108.     } bind def
  1109.  
  1110.    currentdict
  1111.   end
  1112.   dup /CIDFontName get exch /CIDFont defineresource
  1113. } bind def
  1114.  
  1115. % <CIDFont-resource> <CIDFontName> findCIDFont <CIDFont-resource> <font>
  1116. %   CIDFont-resource is not modified.
  1117. /findCIDFont {
  1118.   {
  1119.     dup /CIDFont resourcestatus {
  1120.       pop pop /CIDFont findresource
  1121.       exit
  1122.     } if
  1123.  
  1124.     dup dup length string cvs
  1125.     (,Bold) tailmatch {
  1126.       exch pop
  1127.       cvn findCIDFont 0.03 makeboldcidfont
  1128.       exit
  1129.     } if
  1130.     (,Italic) tailmatch {
  1131.       exch pop
  1132.       cvn findCIDFont
  1133.       [ 1 0 0.3 1 0 0 ] makefont
  1134.       exit
  1135.     } if
  1136.     (,BoldItalic) tailmatch {
  1137.       exch pop
  1138.       cvn findCIDFont 0.03 makeboldcidfont
  1139.       [ 1 0 0.3 1 0 0 ] makefont
  1140.       exit
  1141.     } if
  1142.     pop
  1143.  
  1144.     1 index /CIDSystemInfo get begin Registry (-) Ordering end
  1145.     concatstrings concatstrings
  1146.     cvn
  1147.     QUIET not {
  1148.       (Substituting ) print dup ==only
  1149.       ( for ) print 1 index ==only (.\n) print
  1150.     } if
  1151.     exch pop
  1152.     /CIDFont findresource
  1153.     exit
  1154.   } loop
  1155. } bdef
  1156.  
  1157. /buildCIDType0 {    % <CIDFontType0-font-resource> buildCIDType0 <font>
  1158.   dup /BaseFont get exch 1 index findCIDFont
  1159.   addCIDmetrics /CIDFont defineresource
  1160. } bdef
  1161.  
  1162. /buildCIDType2 {    % <CIDFontType2-font-resource> buildCIDType2 <font>
  1163.   dup /BaseFont get exch 1 index findCIDFont
  1164.   addCIDmetrics /CIDFont defineresource
  1165. } bdef
  1166.  
  1167. % ---------------- Other embedded fonts ---------------- %
  1168.  
  1169. /fontloadprocs mark
  1170.   /Type1C /readType1C cvx
  1171.   /CIDFontType0C /readCIDFontType0C cvx
  1172. .dicttomark readonly def
  1173.  
  1174. % Read an embedded compressed font.
  1175. /readType1C {        % <font-resource> <stream-dict> readType1C <font>
  1176.   1 index exch
  1177.   PDFfile fileposition 3 1 roll
  1178.   dup true resolvestream dup readfontfilter
  1179.         % Stack: pos resource streamdict stream filter
  1180.   3 index /FontDescriptor oget /FontName oget
  1181.   1 index FRD
  1182.   closefile closefile pop
  1183.   PDFfile 3 -1 roll setfileposition
  1184.   /FontDescriptor oget /FontName oget findfont
  1185.   adjustfont
  1186. } bdef
  1187.  
  1188. % Read an embedded CFF CIDFont.
  1189. /readCIDFontType0C {  % <font-resource> <stream-dict> readCIDFontType0C <font>
  1190.   PDFfile fileposition 3 1 roll
  1191.   dup true resolvestream dup readfontfilter
  1192.         % Stack: pos resource streamdict stream filter
  1193.   3 index /FontDescriptor oget /FontName oget
  1194.   1 index FRD
  1195.   closefile closefile pop
  1196.   PDFfile 3 -1 roll setfileposition
  1197.         % Some broken Adobe software produces PDF files in which
  1198.         % the FontName of the CFF font and the FontName in the
  1199.         % FontDescriptor don't match the BaseFont in the font.
  1200.         % Use the FontName, rather than the BaseFont, here.
  1201.   dup /FontDescriptor oget /FontName oget /CIDFont findresource
  1202.   addCIDmetrics dup /CIDFontName get exch /CIDFont defineresource
  1203. } bdef
  1204.  
  1205. % ---------------- Font lookup ---------------- %
  1206.  
  1207. /fonttypeprocs mark        % <font-resource> -proc- <font>
  1208.   /Type0 /buildType0 cvx
  1209.   /Type1 /buildType1 cvx
  1210.   /MMType1 1 index
  1211.   /Type3 /buildType3 cvx
  1212.   /TrueType /buildTrueType cvx
  1213.   /CIDFontType0 /buildCIDType0 cvx
  1214.   /CIDFontType2 /buildCIDType2 cvx
  1215. .dicttomark readonly def
  1216.  
  1217. /resourcefont            % <font-resource> resourcefont <font>
  1218.  { dup /PSFont .knownget
  1219.     { /FID .knownget { type /fonttype eq } { false } ifelse }
  1220.     { false }
  1221.    ifelse
  1222.     { /PSFont get
  1223.     }
  1224.     { dup dup /FontDescriptor knownoget
  1225.        {    % Stack: font-res font-res font-desc
  1226.      dup /FontFile knownoget
  1227.       { exch pop readtype1 true }
  1228.       { dup /FontFile2 knownoget
  1229.          { exch pop readtruetype true }
  1230.          { /FontFile3 knownoget
  1231.         { dup /Subtype get fontloadprocs exch get exec true }
  1232.         { false }
  1233.            ifelse
  1234.          }
  1235.         ifelse
  1236.       }
  1237.      ifelse
  1238.        }
  1239.        { false }
  1240.       ifelse
  1241.         % Stack: font-res font-res false
  1242.         %  -or-: font-res font true
  1243.       not
  1244.        { dup /Subtype get fonttypeprocs exch get exec }
  1245.       if
  1246.       2 copy /PSFont exch put
  1247.       exch pop
  1248.     }
  1249.    ifelse
  1250.  } bdef
  1251.  
  1252. drawopdict begin
  1253.   /d0 {
  1254.     .adjustcharwidth setcharwidth
  1255.   } bdef
  1256.   /d1 {
  1257.     6 -2 roll .adjustcharwidth 6 2 roll setcachedevice
  1258.   } bdef
  1259.   /Tf {
  1260.     1 index Page /Font rget not { 1 index /invalidfont signalerror } if
  1261.     resourcefont exch Tf pop
  1262.   } bdef
  1263. end
  1264.  
  1265. end            % pdfdict
  1266. end            % GS_PDF_ProcSet
  1267. .setglobal
  1268.